//package juc.aqs;
//
//import juc.synchronize.MyLock;
//import lombok.extern.slf4j.Slf4j;
//
//import java.util.Queue;
//import java.util.concurrent.LinkedBlockingQueue;
//import java.util.concurrent.TimeUnit;
//import java.util.concurrent.locks.AbstractQueuedSynchronizer;
//import java.util.concurrent.locks.Condition;
//import java.util.concurrent.locks.Lock;
//
///**
// * @author 况祥彬
// * @date 2020/12/12 14:59
// **/
//
///**
// * 自定义不可重入锁，并用来实现生产消费模型
// */
//@Slf4j
//class test {
//    static int count = 1;
//
//    public static void main(String[] args) {
//        myAqs lock = new myAqs();
//        Condition producerCondition = lock.newCondition();
//        Condition consumerCondition = lock.newCondition();
//        Queue<Integer> queue = new LinkedBlockingQueue<>();
//        int capcity = 10;
//
//        new Thread(() -> {
//            lock.lock();
//            try {
//                while (true) {
//                    while (queue.size() == capcity) {
//                        try {
//                            log.debug("队列满了。。。。");
//                            producerCondition.await();
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//                    }
//                    try {
//                        TimeUnit.SECONDS.sleep(1);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    queue.add(count);
//                    log.debug("生产{}", count++);
//                    consumerCondition.signalAll();
//                }
//            }finally {
//                lock.unlock();
//            }
//        },"AAA").start();
//
//        new Thread(() -> {
//            lock.lock();
//
//                try {
//                    while (true) {
//                    while (queue.isEmpty()) {
//                        try {
//                            log.debug("队列空了。。。。");
//                            consumerCondition.await();
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//                    }
//                        try {
//                            TimeUnit.SECONDS.sleep(1);
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
//                    Integer poll = queue.poll();
//                    log.debug("消费{}", poll);
//                    producerCondition.signalAll();
//                }
//                } finally {
//                    lock.unlock();
//                }
//            },"BBB").start();
//
//    }
//}
//
//public class myAqs implements Lock {
//    private Sync sync = new Sync();
//
//    /**
//     * 同步器类 0无锁 1锁
//     */
//    class Sync extends AbstractQueuedSynchronizer {
//        @Override
//        protected boolean tryAcquire(int arg) {
//            if (compareAndSetState(0, 1)) {
//                setExclusiveOwnerThread(Thread.currentThread());
//                return true;//获取锁成功
//            }
//            return false;
//        }
//
//        @Override
//        protected boolean tryRelease(int arg) {
//            setExclusiveOwnerThread(null);
//            setState(0);
//            return true;
//        }
//
//        @Override
//        protected boolean isHeldExclusively() {
//            return getState() == 1;
//        }
//
//        public Condition newCondition() {
//            return new ConditionObject();
//        }
//    }
//
//    @Override
//    public void lock() {
//        sync.acquire(1);
//    }
//
//    @Override
//    public void lockInterruptibly() throws InterruptedException {
//        sync.acquireInterruptibly(1);
//    }
//
//    @Override
//    public boolean tryLock() {
//        return sync.tryAcquire(1);
//    }
//
//    @Override
//    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
//        return sync.tryAcquireNanos(1, unit.toNanos(time));
//    }
//
//    @Override
//    public void unlock() {
//        sync.release(1);
//    }
//
//    @Override
//    public Condition newCondition() {
//        return sync.newCondition();
//    }
//}
